typora-copy-images-to: img

1. File类概述

File类用于封装一个路径，这个路径可以是从系统盘符开始的绝对路径，如：“D:\file\a.txt”，也可以是相对于当前目录而言的相对路径，如：“src\Hello.java”。File类内部封装的路径可以指向一个文件，也可以指向一个目录，在File类中提供了针对这些文件或目录的一些常规操作。

文件和目录路径名的抽象表示形式，表示一个文件或文件夹，并提供了一系列操作文件或文件夹的方法

File类中提供了一系列方法，用于操作其内部封装的路径指向的文件或者目录，例如判断文件/目录是否存在、创建、删除文件/目录等。

1500708828607

2. 构造方法

方法 功能描述
File(String pathname) 根据路径得到File对象
File(String parent,String child) 根据目录和子文件/目录得到对象
File(File parent,String child) 根据父File对象和子文件/目录得到对象

示例代码

  1. package cn.itcast_01;
  2. import java.io.File;
  3. /*
  4.  * 我们要想实现IO的操作，就必须知道硬盘上文件的表现形式。
  5.  * 而Java就提供了一个类File供我们使用。
  6.  * 
  7.  * File:文件和目录(文件夹)路径名的抽象表示形式
  8.  * 构造方法：
  9.  *         File(String pathname)：根据一个路径得到File对象
  10.  *         File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
  11.  *         File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
  12.  */
  13. public class FileDemo {
  14.     public static void main(String[] args) {
  15.         // File(String pathname)：根据一个路径得到File对象
  16.         // 把e:\\demo\\a.txt封装成一个File对象
  17.         File file = new File("E:\\demo\\a.txt");
  19.         // File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
  20.         File file2 = new File("E:\\demo", "a.txt");
  22.         // File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
  23.         File file3 = new File("e:\\demo");
  24.         File file4 = new File(file3, "a.txt");
  26.         // 以上三种方式其实效果一样
  27.     }
  28. }

3. 创建功能

返回值 方法 功能描述
boolean createNewFile() 创建文件
File createTempFile() 创建一个用于缓存的临时文件
boolean mkdir() 创建文件夹
boolean mkdirs() 创建多级文件夹，如果父级文件夹不存在，会自动创建

代码示例

  1. package cn.itcast_02;
  2. import java.io.File;
  3. import java.io.IOException;
  4. /*
  5.  *创建功能：
  6.  *public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
  7.  *public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
  8.  *public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
  9.  */
  10. public class FileDemo {
  11.     public static void main(String[] args) throws IOException {
  12.         // 需求：我要在e盘目录下创建一个文件夹demo
  13.         File file = new File("e:\\demo");
  14.         System.out.println("mkdir:" + file.mkdir());
  16.         // 需求:我要在e盘目录demo下创建一个文件a.txt
  17.         File file2 = new File("e:\\demo\\a.txt");
  18.         System.out.println("createNewFile:" + file2.createNewFile());
  20.         // 需求：我要在e盘目录test下创建一个文件b.txt
  21.         // Exception in thread "main" java.io.IOException: 系统找不到指定的路径。
  22.         // 注意：要想在某个目录下创建内容，该目录首先必须存在。
  23.         // File file3 = new File("e:\\test\\b.txt");
  24.         // System.out.println("createNewFile:" + file3.createNewFile());
  26.         // 需求:我要在e盘目录test下创建aaa目录
  27.         // File file4 = new File("e:\\test\\aaa");
  28.         // System.out.println("mkdir:" + file4.mkdir());
  30.         // File file5 = new File("e:\\test");
  31.         // File file6 = new File("e:\\test\\aaa");
  32.         // System.out.println("mkdir:" + file5.mkdir());
  33.         // System.out.println("mkdir:" + file6.mkdir());
  35.         // 其实我们有更简单的方法
  36.         File file7 = new File("e:\\aaa\\bbb\\ccc\\ddd");
  37.         System.out.println("mkdirs:" + file7.mkdirs());
  39.         // 看下面的这个东西：
  40.         File file8 = new File("e:\\liuyi\\a.txt");
  41.         System.out.println("mkdirs:" + file8.mkdirs());
  42.     }
  43. }

4. 删除功能

返回值 方法 功能描述
boolean delete() 删除文件或文件夹
void deleteOnExit() JVM退出时删除File对象对应的文件和目录

代码示例

  1. package cn.itcast_03;
  2. import java.io.File;
  3. import java.io.IOException;
  4. /*
  5.  * 删除功能:public boolean delete()
  6.  * 
  7.  * 注意：
  8.  *         A:如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。
  9.  *         B:Java中的删除不走回收站。
  10.  *         C:要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹
  11.  */
  12. public class FileDemo {
  13.     public static void main(String[] args) throws IOException {
  14.         // 创建文件
  15.         // File file = new File("e:\\a.txt");
  16.         // System.out.println("createNewFile:" + file.createNewFile());
  18.         // 我不小心写成这个样子了
  19.         File file = new File("a.txt");
  20.         System.out.println("createNewFile:" + file.createNewFile());
  22.         // 继续玩几个
  23.         File file2 = new File("aaa\\bbb\\ccc");
  24.         System.out.println("mkdirs:" + file2.mkdirs());
  26.         // 删除功能：我要删除a.txt这个文件
  27.         File file3 = new File("a.txt");
  28.         System.out.println("delete:" + file3.delete());
  30.         // 删除功能：我要删除ccc这个文件夹
  31.         File file4 = new File("aaa\\bbb\\ccc");
  32.         System.out.println("delete:" + file4.delete());
  34.         // 删除功能：我要删除aaa文件夹
  35.         // File file5 = new File("aaa");
  36.         // System.out.println("delete:" + file5.delete());
  38.         File file6 = new File("aaa\\bbb");
  39.         File file7 = new File("aaa");
  40.         System.out.println("delete:" + file6.delete());
  41.         System.out.println("delete:" + file7.delete());
  42.     }
  43. }

5. 重命名功能

方法 功能描述
renamneTo(File dest) 路径名相同就是重命名，不一样就是改名加剪切

代码示例

  1. package cn.itcast_04;
  2. import java.io.File;
  3. /*
  4.  * 重命名功能:public boolean renameTo(File dest)
  5.  *         如果路径名相同，就是改名。
  6.  *         如果路径名不同，就是改名并剪切。
  7.  * 
  8.  * 路径以盘符开始：绝对路径    c:\\a.txt
  9.  * 路径不以盘符开始：相对路径    a.txt
  10.  */
  11. public class FileDemo {
  12.     public static void main(String[] args) {
  13.         // 创建一个文件对象
  14.         // File file = new File("林青霞.jpg");
  15.         // // 需求：我要修改这个文件的名称为"东方不败.jpg"
  16.         // File newFile = new File("东方不败.jpg");
  17.         // System.out.println("renameTo:" + file.renameTo(newFile));
  19.         File file2 = new File("东方不败.jpg");
  20.         File newFile2 = new File("e:\\林青霞.jpg");
  21.         System.out.println("renameTo:" + file2.renameTo(newFile2));
  22.     }
  23. }

6. 判断功能

方法 功能描述
isDirectory() 判断是否是目录
isFile() 判断是否是文件
exists() 判断是否是存在
canRead() 判断是否是可读
canWrite() 判断是否是可写
isHidden() 判断是否是隐藏
isAbsolute() 是否是绝对路径

示例代码

  1. import java.io.File;  
  3. /* 
  4.  * 判断功能: 
  5.  * public boolean isDirectory():判断是否是目录 
  6.  * public boolean isFile():判断是否是文件 
  7.  * public boolean exists():判断是否存在 
  8.  * public boolean canRead():判断是否可读 
  9.  * public boolean canWrite():判断是否可写 
  10.  * public boolean isHidden():判断是否隐藏 
  11.  */  
  12. public class FileDemo {  
  13.     public static void main(String[] args) {  
  14.         // 创建文件对象  
  15.         File file = new File("a.txt");  
  17.         System.out.println("isDirectory:" + file.isDirectory());// false  
  18.         System.out.println("isFile:" + file.isFile());// true  
  19.         System.out.println("exists:" + file.exists());// true  
  20.         System.out.println("canRead:" + file.canRead());// true  
  21.         System.out.println("canWrite:" + file.canWrite());// true  
  22.         System.out.println("isHidden:" + file.isHidden());// false  
  23.     }  
  24. }

7. 获取功能

返回值 方法 功能描述
String getAbsolutePath() 获取绝对路径
String getPath() 获取相对路径
String getParent() 获取父目录
String getName() 获取名称
long getFreeSpace() 获取剩余可用空间
long getTotalSpace() 获取总大小
long length() 获取长度，字节数
long lastModified() 获取最后一次修改时间，毫秒值
String[] list() 获取指定目录下的所有文件或文件夹的名称数组
File[] listFiles() 获取指定目录下的所有文件或文件夹的File数组

代码示例

  1. package cn.itcast_06;
  2. import java.io.File;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  5. /*
  6.  * 获取功能：
  7.  * public String getAbsolutePath()：获取绝对路径
  8.  * public String getPath():获取相对路径
  9.  * public String getName():获取名称
  10.  * public long length():获取长度。字节数
  11.  * public long lastModified():获取最后一次的修改时间，毫秒值
  12.  */
  13. public class FileDemo {
  14.     public static void main(String[] args) {
  15.         // 创建文件对象
  16.         File file = new File("demo\\test.txt");
  18.         System.out.println("getAbsolutePath:" + file.getAbsolutePath());
  19.         System.out.println("getPath:" + file.getPath());
  20.         System.out.println("getName:" + file.getName());
  21.         System.out.println("length:" + file.length());
  22.         System.out.println("lastModified:" + file.lastModified());
  24.         // 1416471971031
  25.         Date d = new Date(1416471971031L);
  26.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  27.         String s = sdf.format(d);
  28.         System.out.println(s);
  29.     }
  30. }

运行结果：

  1. getAbsolutePath:D:\workspace\Test\demo\test.txt
  2. getPath:demo\test.txt
  3. getName:test.txt
  4. length:0
  5. lastModified:0
  6. 2014-11-20 16:26:11

判断缓存文件是否过期

  1. File file = ...;
  2. long time = System.currentTimeMillis() - file.lastModified();
  3. if (time < cachetime){
  4.     // 缓存时间小于指定的时间，缓存有效，否则缓存过期
  5. }else {
  7. }

8. 高级获取功能

返回值 方法 功能描述
String[] list(FilenameFilter filter) 返回满足条件的文件名数组
File[] listFiles(FilenameFilter filter) 返回满足条件的文件数组
File[] listRoots() 列出系统所有的根路径 
  1. package cn.itcast_07;
  2. import java.io.File;
  3. /*
  4.  * 高级获取功能：
  5.  * public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
  6.  * public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
  7.  */
  8. public class FileDemo {
  9.     public static void main(String[] args) {
  10.         // 指定一个目录
  11.         File file = new File("e:\\");
  13.         // public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
  14.         String[] strArray = file.list();
  15.         for (String s : strArray) {
  16.             System.out.println(s);
  17.         }
  18.         System.out.println("------------");
  20.         // public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
  21.         File[] fileArray = file.listFiles();
  22.         for (File f : fileArray) {
  23.             System.out.println(f.getName());
  24.         }
  25.     }
  26. }

运行结果：

file

9. 文件过滤器

  • list(FilenameFilter filter)
  • listFiles(FilenameFilter filter)

FilenameFilter 接口

  • accept(File dir, String name)

10. File练习

文件名称过滤器的实现思想及代码

  • public String[] list(FilenameFilter filter)
  • public File[] listFiles(FilenameFilter filter)

10.1 文件名称过滤器的实现

  1. package cn.itcast_08;
  2. import java.io.File;
  3. import java.io.FilenameFilter;
  4. /*
  5.  * 判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
  6.  * A:先获取所有的，然后遍历的时候，依次判断，如果满足条件就输出。
  7.  * B:获取的时候就已经是满足条件的了，然后输出即可。
  8.  * 
  9.  * 要想实现这个效果，就必须学习一个接口：文件名称过滤器
  10.  * public String[] list(FilenameFilter filter)
  11.  * public File[] listFiles(FilenameFilter filter)
  12.  */
  13. public class FileDemo2 {
  14.     public static void main(String[] args) {
  15.         // 封装e判断目录
  16.         File file = new File("e:\\");
  18.         // 获取该目录下所有文件或者文件夹的String数组
  19.         // public String[] list(FilenameFilter filter)
  20.         String[] strArray = file.list(new FilenameFilter() {
  21.             @Override
  22.             public boolean accept(File dir, String name) {
  23.                 // return false;
  24.                 // return true;
  25.                 // 通过这个测试，我们就知道了，到底把这个文件或者文件夹的名称加不加到数组中，取决于这里的返回值是true还是false
  26.                 // 所以，这个的true或者false应该是我们通过某种判断得到的
  27.                 // System.out.println(dir + "---" + name);
  28.                 // File file = new File(dir, name);
  29.                 // // System.out.println(file);
  30.                 // boolean flag = file.isFile();
  31.                 // boolean flag2 = name.endsWith(".jpg");
  32.                 // return flag && flag2;
  33.                 return new File(dir, name).isFile() && name.endsWith(".jpg");
  34.             }
  35.         });
  37.         // 遍历
  38.         for (String s : strArray) {
  39.             System.out.println(s);
  40.         }
  41.     }
  42. }

10.2 递归遍历目录下指定后缀名结尾的文件名称

  1. package cn.itcast_03;
  2. import java.io.File;
  3. /*
  4.  * 需求：把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。
  5.  * 
  6.  * 分析：
  7.  *         A:封装目录
  8.  *         B:获取该目录下所有的文件或者文件夹的File数组
  9.  *         C:遍历该File数组，得到每一个File对象
  10.  *         D:判断该File对象是否是文件夹
  11.  *             是：回到B
  12.  *             否：继续判断是否以.java结尾
  13.  *                 是：就输出该文件的绝对路径
  14.  *                 否：不搭理它
  15.  */
  16. public class FilePathDemo {
  17.     public static void main(String[] args) {
  18.         // 封装目录
  19.         File srcFolder = new File("E:\\JavaSE");
  21.         // 递归功能实现
  22.         getAllJavaFilePaths(srcFolder);
  23.     }
  25.     private static void getAllJavaFilePaths(File srcFolder) {
  26.         // 获取该目录下所有的文件或者文件夹的File数组
  27.         File[] fileArray = srcFolder.listFiles();
  29.         // 遍历该File数组，得到每一个File对象
  30.         for (File file : fileArray) {
  31.             // 判断该File对象是否是文件夹
  32.             if (file.isDirectory()) {
  33.                 getAllJavaFilePaths(file);
  34.             } else {
  35.                 // 继续判断是否以.java结尾
  36.                 if (file.getName().endsWith(".java")) {
  37.                     // 就输出该文件的绝对路径
  38.                     System.out.println(file.getAbsolutePath());
  39.                 }
  40.             }
  41.         }
  42.     }
  43. }

运行结果：

IO流之File类 - 图3

10.3 递归删除带内容的目录

  1. package cn.itcast_03;
  2. import java.io.File;
  3. /*
  4.  * 需求：递归删除带内容的目录
  5.  * 
  6.  * 分析：
  7.  *         A:封装目录
  8.  *         B:获取该目录下的所有文件或者文件夹的File数组
  9.  *         C:遍历该File数组，得到每一个File对象
  10.  *         D:判断该File对象是否是文件夹
  11.  *             是：回到B
  12.  *             否：就删除
  13.  */
  14. public class FileDeleteDemo {
  15.     public static void main(String[] args) {
  16.         // 封装目录
  17.         File srcFolder = new File("demo");
  18.         // 递归实现
  19.         deleteFolder(srcFolder);
  20.     }
  22.     private static void deleteFolder(File srcFolder) {
  23.         // 获取该目录下的所有文件或者文件夹的File数组
  24.         File[] fileArray = srcFolder.listFiles();
  26.         if (fileArray != null) {
  27.             // 遍历该File数组，得到每一个File对象
  28.             for (File file : fileArray) {
  29.                 // 判断该File对象是否是文件夹
  30.                 if (file.isDirectory()) {
  31.                     deleteFolder(file);
  32.                 } else {
  33.                     System.out.println(file.getName() + "---" + file.delete());
  34.                 }
  35.             }
  37.             System.out.println(srcFolder.getName() + "---" + srcFolder.delete());
  38.         }
  39.     }
  40. }

运行结果：

file

10.4 模拟文件管理器

DocumentManager

  1. package cn.itcast.chapter07.task03;
  3. import java.io.File;
  4. import java.util.ArrayList;
  5. import java.util.Scanner;
  7. public class DocumentManager {
  8.     public static void main(String[] args) throws Exception {
  9.         Scanner sc = new Scanner(System.in);
  10.         System.out.println("--1:指定关键字检索文件  2:指定后缀名检索文件  " + "3:复制文件/目录  4:退出--");
  11.         while (true) {
  12.             System.out.print("请输入指令：");
  13.             int command = sc.nextInt();
  14.             switch (command) {
  15.             case 1:
  16.                 searchByKeyWorld();// 指定关键字检索文件
  17.                 break;
  18.             case 2:
  19.                 searchBySuffix();// 指定后缀名检索文件
  20.                 break;
  21.             case 3:
  22.                 copyDirectory();// 复制文件/目录
  23.                 break;
  24.             case 4:
  25.                 exit();// 退出
  26.                 break;
  27.             default:
  28.                 System.out.println("您输入的指令错误！");
  29.                 break;
  30.             }
  31.         }
  32.     }
  34.     // *********1.指定关键字检索文件*********
  35.     private static void searchByKeyWorld() {
  36.         Scanner sc = new Scanner(System.in);
  37.         System.out.print("请输入要检索的目录位置：");
  38.         String path = sc.next();// 从控制台获取路径
  39.         File file = new File(path);
  40.         if (!file.exists() || !file.isDirectory()) {// 判断目录是否存在，是否是目录
  41.             System.out.println(path + " (不是有效目录)");
  42.             return;
  43.         }
  44.         System.out.print("请输入搜索关键字：");
  45.         String key = sc.next();// 获取关键字
  46.         // 在输入目录下获取所有包含关键字的文件路径
  47.         ArrayList<String> list = FileUtils.listFiles(file, key);
  48.         for (Object obj : list) {
  49.             System.out.println(obj);// 将路径打印到控制台
  50.         }
  51.     }
  53.     // *********2.指定后缀名检索文件********//
  54.     private static void searchBySuffix() {
  55.         Scanner sc = new Scanner(System.in);
  56.         System.out.print("请输入要检索的目录位置：");
  57.         String path = sc.next();// 从控制台获取路径
  58.         File file = new File(path);
  59.         if (!file.exists() || !file.isDirectory()) {// 判断目录是否存在，是否是目录
  60.             System.out.println(path + " (不是有效目录)");
  61.             return;
  62.         }
  63.         System.out.print("请输入搜索后缀：");
  64.         String suffix = sc.next();
  65.         String[] suffixArray = suffix.split(",");// 获取后缀字符串
  66.         // 在输入目录下获取所有指定后缀名的文件路径
  67.         ArrayList<String> list = FileUtils.listFiles(file, suffixArray);
  68.         for (Object obj : list) {
  69.             System.out.println(obj);// 将路径打印到控制台
  70.         }
  71.     }
  73.     // *********3.复制文件/目录**********//
  74.     private static void copyDirectory() throws Exception {
  75.         Scanner sc = new Scanner(System.in);
  76.         System.out.print("请输入源目录：");
  77.         String srcDirectory = sc.next();// 从控制台获取源路径
  78.         File srcFile = new File(srcDirectory);
  79.         if (!srcFile.exists() || !srcFile.isDirectory()) {// 判断目录是否存在，是否是目录
  80.             System.out.println("无效目录！");
  81.             return;
  82.         }
  83.         System.out.print("请输入目标位置：");
  84.         String destDirectory = sc.next();// 从控制台获取目标路径
  85.         File destFile = new File(destDirectory);
  86.         if (!destFile.exists() || !destFile.isDirectory()) {// 判断目录是否存在，是否是目录
  87.             System.out.println("无效位置！");
  88.             return;
  89.         }
  90.         // 将源路径中的内容复制到目标路径下
  91.         FileUtils.copySrcPathToDestPath(srcFile, destFile);
  92.     }
  94.     // *********4.退出**********//
  95.     private static void exit() {
  96.         System.out.println("您已退出系统，谢谢使用！");
  97.         System.exit(0);
  98.     }
  99. }

FileUtils

  1. package cn.itcast.chapter07.task03;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.FilenameFilter;
  7. import java.util.ArrayList;
  9. public class FileUtils {
  10.     /**
  11.      * 指定关键字检索文件
  12.      * @param file   File对象
  13.      * @param key    关键字
  14.      * @return 包含关键字的文件路径
  15.      */
  16.     public static ArrayList<String> listFiles(File file, final String key) {
  17.         FilenameFilter filter = new FilenameFilter() { // 创建过滤器对象
  18.             public boolean accept(File dir, String name) {// 实现accept()方法
  19.                 File currFile = new File(dir, name);
  20.                 // 如果文件名包含关键字返回true，否则返回false
  21.                 if (currFile.isFile() && name.contains(key)) {
  22.                     return true;
  23.                 }
  24.                 return false;
  25.             }
  26.         };
  27.         // 递归方式获取规定的路径
  28.         ArrayList<String> arraylist = fileDir(file, filter);
  29.         return arraylist;
  30.     }
  32.     /**
  33.      * 指定后缀名检索文件
  34.      * @param file   File对象
  35.      * @param suffixArray   后缀名数组
  36.      * @return 指定后缀名的文件路径
  37.      */
  38.     public static ArrayList<String> listFiles(File file,
  39.             final String[] suffixArray) {
  40.         FilenameFilter filter = new FilenameFilter() { // 创建过滤器对象
  41.             public boolean accept(File dir, String name) {// 实现accept()方法
  42.                 File currFile = new File(dir, name);
  43.                 if (currFile.isFile()) {// 如果文件名以指定后缀名结尾返回true，否则返回false
  44.                     for (String suffix : suffixArray) {
  45.                         if (name.endsWith("." + suffix)) {
  46.                             return true;
  47.                         }
  48.                     }
  49.                 }
  50.                 return false;
  51.             }
  52.         };
  53.         // 递归方式获取规定的路径
  54.         ArrayList<String> arraylist = fileDir(file, filter);
  55.         return arraylist;
  56.     }
  58.     /**
  59.      * 递归方式获取规定的路径
  60.      * @param dir   File对象
  61.      * @param filter   过滤器
  62.      * @return 过滤器过滤后的文件路径
  63.      */
  64.     public static ArrayList<String> fileDir(File dir, FilenameFilter filter) {
  65.         ArrayList<String> arraylist = new ArrayList<String>();
  66.         File[] lists = dir.listFiles(filter); // 获得过滤后的所有文件数组
  67.         for (File list : lists) {
  68.             // 将文件的绝对路径放到集合中
  69.             arraylist.add(list.getAbsolutePath());
  70.         }
  71.         File[] files = dir.listFiles(); // 获得当前目录下所有文件的数组
  72.         for (File file : files) { // 遍历所有的子目录和文件
  73.             if (file.isDirectory()) {
  74.                 // 如果是目录，递归调用fileDir()
  75.                 ArrayList<String> every = fileDir(file, filter);
  76.                 arraylist.addAll(every);// 将文件夹下的文件路径添加到集合中
  77.             }
  78.         }// 此时的集合中有当前目录下的文件路径，和当前目录的子目录下的文件路径
  79.         return arraylist;
  80.     }
  82.     /**
  83.      * 复制文件/目录
  84.      * @param srcFile   源目录
  85.      * @param destFile  目标目录
  86.      */
  87.     public static void copySrcPathToDestPath(File srcDir, File destDir)
  88.             throws Exception {
  89.         File[] files = srcDir.listFiles();// 子文件目录
  90.         for (int i = 0; i < files.length; i++) {
  91.             File copiedFile = new File(destDir, files[i].getName());// 创建指定目录的文件
  92.             if (files[i].isDirectory()) {// 如果是目录
  93.                 if (!copiedFile.mkdirs()) {// 创建文件夹
  94.                     System.out.println("无法创建：" + copiedFile);
  95.                     return;
  96.                 }
  97.                 // 调用递归，获取子文件夹下的文件路径
  98.                 copySrcPathToDestPath(files[i], copiedFile);
  99.             } else {// 复制文件
  100.                 FileInputStream input = new FileInputStream(files[i]);// 获取输入流
  101.                 FileOutputStream output = new FileOutputStream(copiedFile);// 获取输出流
  102.                 byte[] buffer = new byte[1024];// 创建缓冲区
  103.                 int n = 0;
  104.                 // 循环读取字节
  105.                 while ((n = input.read(buffer)) != -1) {
  106.                     output.write(buffer, 0, n);
  107.                 }
  108.                 input.close();// 关闭输入流
  109.                 output.close();// 关闭输出流
  110.             }
  111.         }
  112.     }
  113. }